package cn.org.xwb.bookmall.model.service.impl;

import cn.org.xwb.bookmall.model.constant.ProductConst;
import cn.org.xwb.bookmall.model.po.ProductCategory;
import cn.org.xwb.bookmall.model.mapper.ProductCategoryMapper;
import cn.org.xwb.bookmall.model.service.IProductCategoryService;
import cn.org.xwb.bookmall.model.utils.BookRedisUtil;
import cn.org.xwb.bookmall.model.vo.ProductCategoryVo;
import cn.org.xwb.common.page.dto.PageResult;
import cn.org.xwb.common.page.utils.PageUtil;
import cn.org.xwb.common.redis.utils.RedisUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 商品分类表 服务实现类
 * </p>
 *
 * @author xwb
 * @since 2023-11-24
 */
@Service
public class ProductCategoryServiceImpl extends ServiceImpl<ProductCategoryMapper, ProductCategory> implements IProductCategoryService {

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private BookRedisUtil bookRedisUtil;

    private String getKeyProductCategory() {
        return bookRedisUtil.getRedisKeyUser(ProductConst.PRODUCT_CATEGORY, "");
    }

    /**
     * 查询并缓存所有商品分类
     *
     * @return null-发生异常
     */
    @Override
    public List<ProductCategoryVo> findAndCacheAll() {
        // 查询所有
        List<ProductCategoryVo> productCategoryVos = baseMapper.selectAll();
        // 缓存
        Boolean res = redisUtil.setList(getKeyProductCategory(), productCategoryVos);
        // 失败
        if (!res) return null;
        return productCategoryVos;
    }

    /**
     * 从缓存中查询所有商品分类，如果缓存不存在，则从数据库中查询，并缓存
     *
     * @return null-发生异常
     */
    @Override
    public List<ProductCategoryVo> findAllFromCache() {
        // 查询缓存
        List<ProductCategoryVo> productCategoryVos = (ArrayList<ProductCategoryVo>) redisUtil.get(getKeyProductCategory());
        // 缓存中不存在，则从数据库中查询，并缓存
        if (Objects.isNull(productCategoryVos)) productCategoryVos = findAndCacheAll();
        // 发生异常
        if (Objects.isNull(productCategoryVos)) return null;
        // 成功
        return productCategoryVos;
    }

    /**
     * 分页获取商品分类(根据一级商品分类进行分页)
     *
     * @param current
     * @param pageSize 每页数据个数
     * @param disabled
     * @param nameMatch
     * @param codeMatch
     * @return
     */
    @Override
    public PageResult<List<ProductCategoryVo>> findProductCategoryVoPage(Integer current, Integer pageSize, Boolean disabled, String nameMatch, String codeMatch) {
        // 获取全部数据
        List<ProductCategoryVo> productCategoryVos = findAllFromCache();
        // 异常
        if (Objects.isNull(productCategoryVos)) return null;
        // 条件过滤
        // 根据分类是否禁用进行筛选
        if (Objects.nonNull(disabled))
            productCategoryVos = productCategoryVos.stream().filter(productCategoryVo ->  productCategoryVo.getDisabled() == disabled).toList();
        // 根据分类名称模糊匹配进行筛选
        if (Objects.nonNull(nameMatch) && !nameMatch.isEmpty())
            productCategoryVos = productCategoryVos.stream().filter(productCategoryVo -> productCategoryVo.getName().contains(nameMatch)).toList();
        // 根据分类编码模糊匹配进行筛选
        if (Objects.nonNull(codeMatch) && !codeMatch.isEmpty())
            productCategoryVos = productCategoryVos.stream().filter(productCategoryVo -> productCategoryVo.getCode().contains(codeMatch)).toList();
        // 对书籍商品分类数据进行分页操作
        // 页数
        Integer pageCnt = PageUtil.getPageCnt(productCategoryVos.size(), pageSize);
        // 分页数据
        productCategoryVos = (List<ProductCategoryVo>) PageUtil.getPageData(productCategoryVos, current, pageSize);
        return new PageResult<>(current, pageSize, productCategoryVos.size(), pageCnt, productCategoryVos);
    }

    private String getKeyProductCategoryWithImg() {
        return bookRedisUtil.getRedisKeyUser(ProductConst.PRODUCT_CATEGORY_WITH_IMG, "");
    }

    /**
     * 查询并缓存所有商品分类
     *
     * @return null-发生异常
     */
    @Override
    public List<ProductCategoryVo> findAndCacheAllWithImg() {
        // 查询所有
        List<ProductCategoryVo> productCategoryVos = baseMapper.selectAllWithImg();
        // 过滤无子级分类的商品分类(过滤后，存入redis，会失去 list 的类型，导致从redis读取时JSON转换失败)
        // productCategoryVos = productCategoryVos.stream().filter(productCategoryVo -> productCategoryVo.getSubs().size() > 0).toList();
        // 缓存
        Boolean res = redisUtil.setList(getKeyProductCategoryWithImg(), productCategoryVos);
        // 失败
        if (!res) return null;
        return productCategoryVos;
    }

    /**
     * 从缓存中查询所有商品分类，如果缓存不存在，则从数据库中查询，并缓存
     *
     * @return null-发生异常
     */
    @Override
    public List<ProductCategoryVo> findAllFromCacheWithImg() {
        // 查询缓存
        List<ProductCategoryVo> productCategoryVos = (ArrayList<ProductCategoryVo>) redisUtil.get(getKeyProductCategoryWithImg());
        // 缓存中不存在，则从数据库中查询，并缓存
        if (Objects.isNull(productCategoryVos)) productCategoryVos = findAndCacheAllWithImg();
        // 发生异常
        if (Objects.isNull(productCategoryVos)) return null;
        // 成功
        return productCategoryVos;
    }
}
